Grokking Tree Coding Patterns for Interviews
Rate this course
Ask Author
Contribute
Back to course home

0% completed

Vote For New Content
Introduction
Course Overview
Basics of Tree
Introduction to Tree
Types of Tree
BST Traversal Techniques
BST Operations
Level Order Traversal Pattern (easy)
Introduction to Level Order Traversal Pattern
Reverse Level Order Traversal (easy)
Solution: Reverse Level Order Traversal
Find Largest Value in Each Tree Row (medium)
Solution: Find Largest Value in Each Tree Row
Maximum Width of Binary Tree (medium)
Solution: Maximum Width of Binary Tree
Maximum Level Sum of a Binary Tree (medium)
Solution: Maximum Level Sum of a Binary Tree
Zigzag Traversal (medium)
Solution: Zigzag Traversal
Even Odd Tree (medium)
Solution: Even Odd Tree
N-ary Tree Level Order Traversal (hard)
Solution: N-ary Tree Level Order Traversal
Tree Depth Pattern (easy)
Introduction to Tree Depth Pattern
Maximum Depth (or Height) of Binary Tree (easy)
Solution: Maximum Depth (or Height) of Binary Tree
Minimum Depth of a Binary Tree (easy)
Solution: Minimum Depth of a Binary Tree
Balanced Binary Tree (easy)
Solution: Balanced Binary Tree
Tree Diameter (easy)
Solution: Tree Diameter
Maximum Depth of N-ary Tree (easy)
Solution: Maximum Depth of N-ary Tree
Find maximum depth of subtree (medium)
Solution: Find maximum depth of subtree
Introduction to Root to Leaf Path Pattern
Binary Tree Paths (easy)
Solution: Binary Tree Paths
Sum of Root To Leaf Binary Numbers (easy)
Solution: Sum of Root To Leaf Binary Numbers
Insufficient Nodes in Root to Leaf Paths (medium)
Solution: Insufficient Nodes in Root to Leaf Paths
Smallest String Starting From Leaf (medium)
Solution: Smallest String Starting From Leaf
Pseudo-Palindromic Paths in a Binary Tree (medium)
Solution: Pseudo-Palindromic Paths in a Binary Tree
All Paths for a Sum (medium)
Solution: All Paths for a Sum
Sum of Path Numbers (medium)
Solution: Sum of Path Numbers
Path With Given Sequence (medium)
Solution: Path With Given Sequence
Count Paths for a Sum (medium)
Solution: Count Paths for a Sum
Introduction to Leaf Processing Pattern
Sum of Left Leaves (easy)
Solution: Sum of Left Leaves
Leaf-Similar Trees (easy)
Solution: Leaf-Similar Trees
Check if all leaves are at same level (medium)
Solution: Check if all leaves are at same level
Delete Leaves With a Given Value (medium)
Solution: Delete Leaves With a Given Value
Deepest Leaves Sum (medium)
Solution: Deepest Leaves Sum
Introduction to Tree View Pattern
Right View of a Binary Tree (medium)
Solution: Right View of a Binary Tree
Top View Of the Binary Tree (medium)
Solution: Top View Of the Binary Tree
Bottom View Of the Binary Tree (medium)
Solution: Bottom View Of the Binary Tree
Boundary of Binary Tree (medium)
Solution: Boundary of Binary Tree
Introduction to Comparison of Two Trees Pattern
Symmetric Tree (easy)
Solution: Symmetric Tree
Mirror Image Trees (medium)
Solution: Mirror Image Trees
Subtree of Another Tree (easy)
Solution: Subtree of Another Tree
Isomorphic Trees (medium)
Solution: Isomorphic Trees
Introduction to Serialize and Deserialize Tree Pattern
Serialize and Deserialize BST (medium)
Solution: Serialize and Deserialize BST
Verify Preorder Serialization of a Binary Tree (medium)
Solution: Verify Preorder Serialization of a Binary Tree
Create Binary Tree From Descriptions (medium)
Solution: Create Binary Tree From Descriptions
Serialize and Deserialize N-ary Tree (hard)
Solution: Serialize and Deserialize N-ary Tree
Solution: Connect Level Order Siblings

Problem Statement

Given a root of the binary tree, connect each node with its level order successor. The last node of each level should point to a null node.

Examples

Example 1:

  • Input: root = [1, 2, 3, 4, 5, 6, 7]
Image
  • Output:
    [1 -> null]
    [2 -> 3 -> null]
    [4 -> 5 -> 6 -> 7 -> null]
    
  • Explanation:
    The tree is traversed level by level using BFS. Each node is connected to its next right node at the same level. The last node of each level points to null.

Example 2:

  • Input: root = [12, 7, 1, 9, null, 10, 5]
Image
  • Output:
    [12 -> null]
    [7 -> 1 -> null]
    [9 -> 10 -> 5 -> null]
    
  • Explanation:
    The nodes are connected to their next right sibling at the same level. The last node of each level points to null.

Constraints:

  • The number of nodes in the tree is in the range [0, 212 - 1].
  • -1000 <= Node.val <= 1000

Solution

To solve this problem, we perform a level order traversal using Breadth-First Search (BFS) while connecting each node to its immediate right neighbor within the same level. We use a queue to keep track of nodes at each level and maintain a previousNode pointer to establish connections. At the start of each level, previousNode is set to null. As we process nodes within the level, we link previousNode.next to the currentNode, ensuring all siblings are connected. The previousNode is then updated to the currentNode for subsequent connections. Once a node is processed, its left and right children are enqueued so they are available in the next level. The last node of each level remains pointing to null, marking the end of the level's linked sequence.

This approach ensures that all nodes within the same level are properly connected while preserving the correct order of traversal. Once all levels are processed, the modified tree is returned.

Step-by-Step Algorithm

  1. Handle the Base Case:

    • If the root is null, return null immediately.
  2. Initialize BFS:

    • Create a queue and enqueue the root node.
  3. Process Each Level Iteratively:

    • While the queue is not empty:
      • Determine levelSize, the number of nodes in the current level.
      • Initialize previousNode as null to keep track of the last processed node.
  4. Connect Nodes in the Current Level:

    • Iterate over all nodes in the current level:
      • Dequeue the front node.
      • If previousNode is not null, set previousNode.next = currentNode to connect them.
      • Update previousNode to currentNode to store previously processed node for the next level.
      • Enqueue the left and right children (if they exist).
  5. Move to the Next Level and Repeat Until the Queue is Empty.

  6. Return the Modified Tree Root.

Algorithm Walkthrough

Image
  1. Initialize BFS Traversal:

    • Start with the root node 12.
    • Initialize an empty queue and enqueue 12.

    Queue: [12]

  2. Process Level 1 (Root Level):

    • Level Size: 1 (only node 12 in this level).
    • Initialize previousNode = null.
    • Dequeue 12:
      • Since previousNode is null, assign previousNode = 12.
      • Enqueue left child 7.
      • Enqueue right child 1.

    Queue after processing: [7, 1]
    Next Pointer Connection: 12 -> null (last node in level points to null)

  3. Process Level 2:

    • Level Size: 2 (nodes 7 and 1).
    • Initialize previousNode = null.
    • Dequeue 7:
      • Since previousNode is null, assign previousNode = 7.
      • Enqueue left child 9 (no right child for 7).
    • Dequeue 1:
      • Connect 7.next = 1 (link the previous node to the current node).
      • Update previousNode = 1.
      • Enqueue left child 10.
      • Enqueue right child 5.

    Queue after processing: [9, 10, 5]
    Next Pointer Connections: 7 -> 1 -> null

  4. Process Level 3:

    • Level Size: 3 (nodes 9, 10, 5).
    • Initialize previousNode = null.
    • Dequeue 9:
      • Since previousNode is null, assign previousNode = 9.
      • 9 has no children, so nothing is enqueued.
    • Dequeue 10:
      • Connect 9.next = 10 (link the previous node to the current node).
      • Update previousNode = 10.
      • 10 has no children, so nothing is enqueued.
    • Dequeue 5:
      • Connect 10.next = 5 (link the previous node to the current node).
      • Update previousNode = 5.
      • 5 has no children, so nothing is enqueued.

    Queue after processing: [] (No more nodes to process).
    Next Pointer Connections: 9 -> 10 -> 5 -> null

Final Connected Tree

        12 -> null
       /   \
      7  -> 1 -> null
     /    /   \
    9 -> 10 -> 5 -> null

Code

Here is the code for this algorithm:

Java
Saved to Cloud

. . . .

Complexity Analysis

Time Complexity

The time complexity of the above algorithm is , where ‘N’ is the total number of nodes in the tree. This is due to the fact that we traverse each node once.

Space Complexity

The space complexity of the above algorithm will be , which is required for the queue. Since we can have a maximum of nodes at any level (this could happen only at the lowest level), therefore we will need space to store them in the queue.

Connect Level Order Siblings (medium)
Connect All Level Order Siblings (medium)
Mark as Completed

On this page

Problem Statement

Examples

Solution

Step-by-Step Algorithm

Algorithm Walkthrough

Code

Complexity Analysis

Time Complexity

Space Complexity